const { app, BrowserWindow, dialog, ipcMain } = require('electron');
const fs = require('fs');
const path = require('path');
const QRCode = require('qrcode');

function createWindow() {
  const win = new BrowserWindow({
    width: 800,
    height: 700,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
    },
  });

  // 初始化跳过文件日志，确保应用启动时历史记录文件存在
  initializeSkippedFilesLog();

  win.loadFile('index.html');
}

// 获取应用数据目录，用于存储持久化信息
function getUserDataPath() {
  // 在Electron应用中，使用app.getPath('userData')
  // 在开发环境或Node环境中，使用当前目录下的.user-data
  const isElectron = typeof process !== 'undefined' && process.versions && process.versions.electron;
  if (isElectron && app && app.getPath) {
    return app.getPath('userData');
  } else {
    const userDataPath = path.join(__dirname, '.user-data');
    // 确保目录存在
    if (!fs.existsSync(userDataPath)) {
      fs.mkdirSync(userDataPath, { recursive: true });
    }
    return userDataPath;
  }
}

// 创建持久化的跳过文件日志路径
function getSkippedFilesLogPath() {
  const dataPath = getUserDataPath();
  return path.join(dataPath, 'skipped_files_history.json');
}

// 初始化跳过文件历史记录文件
function initializeSkippedFilesLog() {
  const logPath = getSkippedFilesLogPath();
  // 如果文件不存在，创建一个空的数组结构
  if (!fs.existsSync(logPath)) {
    try {
      fs.writeFileSync(logPath, JSON.stringify([], null, 2), 'utf-8');
      console.log(`初始化跳过文件日志: ${logPath}`);
    } catch (error) {
      console.error('初始化跳过文件日志失败:', error);
    }
  }
}

// 检测文件是否为文本文件的函数
function isTextFile(filePath) {
  try {
    // 对于小文件，直接尝试读取并解码
    if (fs.statSync(filePath).size < 100000) { // 小于100KB的文件
      const content = fs.readFileSync(filePath, 'utf-8');
      // 检查是否包含大量不可打印字符
      const nonPrintableChars = (content.match(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g) || []).length;
      return nonPrintableChars / content.length < 0.3; // 如果非打印字符少于30%，则视为文本文件
    }
    // 对于大文件，只读取前1000个字符进行检测
    const buffer = Buffer.alloc(1000);
    const fd = fs.openSync(filePath, 'r');
    fs.readSync(fd, buffer, 0, 1000, 0);
    fs.closeSync(fd);
    
    // 尝试解码为UTF-8
    const content = buffer.toString('utf-8');
    // 检查是否包含大量不可打印字符
    const nonPrintableChars = (content.match(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g) || []).length;
    return nonPrintableChars / content.length < 0.3; // 如果非打印字符少于30%，则视为文本文件
  } catch (error) {
    // 如果解码失败，可能不是文本文件
    console.log(`文件 ${filePath} 可能不是文本文件:`, error.message);
    return false;
  }
}

// 实时记录跳过的文件信息到持久化文件
function logSkippedFile(fileInfo) {
  try {
    // 添加时间戳信息
    const skippedRecord = {
      ...fileInfo,
      timestamp: new Date().toISOString(),
      sessionId: new Date().toISOString().split('T')[0] // 按天分组的会话ID
    };
    
    const logPath = getSkippedFilesLogPath();
    
    // 读取现有数据
    let existingData = [];
    if (fs.existsSync(logPath)) {
      try {
        const existingContent = fs.readFileSync(logPath, 'utf-8');
        if (existingContent.trim()) {
          existingData = JSON.parse(existingContent);
        }
      } catch (readError) {
        console.error('读取现有跳过文件记录失败，创建新记录:', readError);
        existingData = [];
      }
    }
    
    // 添加新记录到开头，使最近的记录在前面
    existingData.unshift(skippedRecord);
    
    // 限制文件大小，只保留最近的1000条记录
    if (existingData.length > 1000) {
      existingData = existingData.slice(0, 1000);
    }
    
    // 写入更新后的数据
    fs.writeFileSync(logPath, JSON.stringify(existingData, null, 2), 'utf-8');
    
    console.log(`实时记录跳过文件: ${fileInfo.path || fileInfo.name}`);
    return true;
  } catch (error) {
    console.error('实时记录跳过文件时出错:', error);
    return false;
  }
}

// 读取所有跳过文件的历史记录
function readSkippedFilesHistory() {
  try {
    const logPath = getSkippedFilesLogPath();
    
    if (fs.existsSync(logPath)) {
      const existingContent = fs.readFileSync(logPath, 'utf-8');
      if (existingContent.trim()) {
        return JSON.parse(existingContent);
      }
    }
    return [];
  } catch (error) {
    console.error('读取跳过文件历史记录失败:', error);
    return [];
  }
}

// 清空跳过文件历史记录
function clearSkippedFilesHistory() {
  try {
    const logPath = getSkippedFilesLogPath();
    fs.writeFileSync(logPath, JSON.stringify([], null, 2), 'utf-8');
    console.log('跳过文件历史记录已清空');
    return true;
  } catch (error) {
    console.error('清空跳过文件历史记录失败:', error);
    return false;
  }
}

// 写入失败或被跳过文件信息到指定的输出目录
function writeSkippedFilesInfo(savePath) {
  try {
    // 创建日志文件路径
    const logFileName = `skipped_files_${new Date().toISOString().replace(/[:.]/g, '-')}.txt`;
    const logFilePath = path.join(savePath, logFileName);
    
    // 读取当前会话的跳过文件记录
    const currentSessionId = new Date().toISOString().split('T')[0];
    const logPath = getSkippedFilesLogPath();
    let sessionRecords = [];
    
    if (fs.existsSync(logPath)) {
      try {
        const existingContent = fs.readFileSync(logPath, 'utf-8');
        if (existingContent.trim()) {
          const allRecords = JSON.parse(existingContent);
          sessionRecords = allRecords.filter(record => record.sessionId === currentSessionId);
        }
      } catch (readError) {
        console.error('读取跳过文件记录失败:', readError);
      }
    }
    
    if (sessionRecords.length === 0) {
      console.log('当前会话没有被跳过的文件信息需要写入');
      return;
    }
    
    // 准备日志内容
    let logContent = '序号,文件路径,文件名,原因,时间戳\n';
    sessionRecords.forEach((record, index) => {
      logContent += `${index + 1},${record.path || ''},${record.name},${record.reason},${record.timestamp}\n`;
    });
    
    // 写入文件
    fs.writeFileSync(logFilePath, logContent, 'utf-8');
    console.log(`被跳过的文件信息已写入: ${logFilePath}`);
    
    return logFilePath;
  } catch (error) {
    console.error('写入被跳过的文件信息时出错:', error);
  }
}

// 判断是否应该过滤路径
function shouldFilterPath(filePath, filterKeywords) {
  if (!filterKeywords) {
    return false;
  }
  
  // 分割文件夹路径，支持多个路径用分号分隔
  const filterDirs = filterKeywords.split(';').map(dir => dir.trim()).filter(dir => dir.length > 0);
  if (filterDirs.length === 0) {
    return false;
  }
  
  // 标准化路径分隔符，转为小写进行比较
  const normalizedFilePath = filePath.toLowerCase().replace(/\\/g, '/');
  
  return filterDirs.some(filterDir => {
    const normalizedFilterDir = filterDir.toLowerCase().replace(/\\/g, '/');
    // 检查路径是否以过滤文件夹路径开头，并且后面要么是结束要么是路径分隔符
    return normalizedFilePath.startsWith(normalizedFilterDir + '/') || 
           normalizedFilePath === normalizedFilterDir;
  });
}

// 递归收集文件夹中的文本文件信息，但不立即读取内容
function getCodeFilesFromDirectory(directory, filterKeywords) {
  const fileInfos = [];
  
  try {
    const entries = fs.readdirSync(directory);
    for (const entry of entries) {
      const fullPath = path.join(directory, entry);
      const stats = fs.statSync(fullPath);
      
      // 检查是否需要过滤此路径
      if (shouldFilterPath(fullPath, filterKeywords)) {
        console.log(`[过滤] 跳过路径: ${fullPath}`);
        logSkippedFile({
          name: entry,
          path: fullPath,
          reason: '路径过滤'
        });
        continue;
      }
      
      if (stats.isDirectory()) {
        // 递归收集子文件夹中的文件信息
        const subFileInfos = getCodeFilesFromDirectory(fullPath, filterKeywords);
        fileInfos.push(...subFileInfos);
      } else {
        // 检查文件是否为文本文件
        if (isTextFile(fullPath)) {
          // 只收集文件信息，不立即读取内容
          fileInfos.push({
            name: entry,
            path: fullPath,
            size: stats.size,
            // 注意：content字段将在分块处理时再读取
          });
        } else {
          // 实时记录被跳过的非文本文件
          logSkippedFile({
            name: entry,
            path: fullPath,
            reason: '非文本文件'
          });
          console.log(`跳过非文本文件: ${fullPath}`);
        }
      }
    }
  } catch (error) {
    console.error('读取文件夹时出错:', error);
    // 实时记录读取失败的文件
    logSkippedFile({
      name: path.basename(directory),
      path: directory,
      reason: `读取失败: ${error.message}`
    });
  }
  
  return fileInfos;
}

// 批量读取文件内容的函数
async function readFilesContentInBatches(fileInfos, batchSize = 10) {
  const results = [];
  
  // 分批处理文件信息
  for (let i = 0; i < fileInfos.length; i += batchSize) {
    const batch = fileInfos.slice(i, i + batchSize);
    
    // 并行读取当前批次的文件内容
    const batchResults = await Promise.all(
      batch.map(async (fileInfo) => {
        try {
          const content = fs.readFileSync(fileInfo.path, 'utf-8');
          return {
            ...fileInfo,
            content: content
          };
        } catch (error) {
          console.error(`读取文件内容时出错: ${fileInfo.path}`, error);
          return {
            ...fileInfo,
            content: '',
            error: error.message
          };
        }
      })
    );
    
    results.push(...batchResults);
    
    // 添加短暂延迟，避免CPU占用过高
    if (i + batchSize < fileInfos.length) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }
  
  return results;
}

// 保存二维码文件的函数
async function saveQRCode(dataUrl, savePath, chunkInfo = {}) {
  try {
    console.log('[saveQRCode] 开始保存二维码，保存路径:', savePath);
    
    // 从chunkInfo中获取文件序号，如果没有则使用1
    let fileIndex = chunkInfo?.fileIndex || 1;
    console.log('[saveQRCode] 文件序号:', fileIndex);
    
    // 判断是否为分片文件及分片索引
    const isSplit = chunkInfo?.isSplit === true;
    const chunkIndex = chunkInfo?.chunkIndex;
    console.log('[saveQRCode] 是否分片:', isSplit, '分片索引:', chunkIndex);
    
    // 确保保存路径存在
    console.log('[saveQRCode] 检查保存路径是否存在:', savePath);
    if (!fs.existsSync(savePath)) {
      console.log('[saveQRCode] 保存路径不存在，创建中...');
      try {
        fs.mkdirSync(savePath, { recursive: true });
        console.log('[saveQRCode] 保存路径创建成功');
      } catch (mkdirError) {
        console.error('[saveQRCode] 创建路径失败:', mkdirError.message);
        return {
          success: false,
          error: '创建保存路径失败',
          details: mkdirError.message
        };
      }
    }
    
    // 生成文件名
    let fileName;
    if (isSplit && chunkIndex !== undefined) {
      fileName = `${fileIndex}-${chunkIndex}.png`;
    } else {
      fileName = `${fileIndex}.png`;
    }
    console.log('[saveQRCode] 生成的文件名:', fileName);
    
    let filePath = path.join(savePath, fileName);
    console.log('[saveQRCode] 完整文件路径:', filePath);
    
    // 验证dataUrl是否有效
    if (!dataUrl || typeof dataUrl !== 'string' || !dataUrl.startsWith('data:image/png;base64,')) {
      console.error('[saveQRCode] 无效的dataUrl:', typeof dataUrl, dataUrl?.substring(0, 30) + '...');
      return {
        success: false,
        error: '无效的二维码数据',
        details: 'dataUrl格式不正确'
      };
    }
    
    // 解码base64数据并写入文件
    console.log('[saveQRCode] 开始解码base64数据...');
    const base64Data = dataUrl.replace(/^data:image\/png;base64,/, '');
    
    console.log('[saveQRCode] 转换base64数据为Buffer...');
    const buffer = Buffer.from(base64Data, 'base64');
    
    console.log('[saveQRCode] 开始写入文件:', filePath);
    
    // 写入文件
    await new Promise((resolve, reject) => {
      fs.writeFile(filePath, buffer, (err) => {
        if (err) {
          console.error('[saveQRCode] 写入文件失败:', err.message);
          reject(err);
        } else {
          console.log('[saveQRCode] 二维码保存成功:', filePath);
          resolve();
        }
      });
    });
    
    return {
      success: true,
      filePath: filePath,
      fileName: path.basename(filePath)
    };
  } catch (error) {
    console.error('[saveQRCode] 保存二维码时出错:', error.message);
    return {
      success: false,
      error: '保存二维码失败',
      details: error.message
    };
  }
}

// 分块处理文件的函数 - 优化版本
async function processFilesInBatches(files, batchSize = 10, processFunction) {
  const startTime = Date.now();
  const operationId = `batch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  
  console.log(`[分批次处理][${operationId}] 开始批处理操作，当前时间: ${new Date().toISOString()}`);
  
  // 参数验证
  if (!Array.isArray(files)) {
    console.error(`[分批次处理][${operationId}] 错误: files参数必须是数组，接收到: ${typeof files}`);
    return {
      success: false,
      error: 'Invalid files parameter',
      successCount: 0,
      errorCount: 0,
      results: [],
      totalBatches: 0,
      totalFiles: 0,
      operationId,
      startTime,
      endTime: Date.now()
    };
  }
  
  if (typeof processFunction !== 'function') {
    console.error(`[分批次处理][${operationId}] 错误: processFunction参数必须是函数，接收到: ${typeof processFunction}`);
    return {
      success: false,
      error: 'Invalid processFunction parameter',
      successCount: 0,
      errorCount: 0,
      results: [],
      totalBatches: 0,
      totalFiles: files.length,
      operationId,
      startTime,
      endTime: Date.now()
    };
  }
  
  // 验证批处理大小
  batchSize = Math.max(1, Math.min(batchSize, files.length));
  
  let successCount = 0;
  let errorCount = 0;
  const allResults = [];
  const totalFiles = files.length;
  const totalBatches = Math.max(1, Math.ceil(totalFiles / batchSize));
  let processedBatches = 0;
  let processedFiles = 0;
  
  console.log(`[分批次处理][${operationId}] 开始处理文件，总文件数: ${totalFiles}，批次大小: ${batchSize}，预计批次: ${totalBatches}`);
  
  // 分批处理文件
  for (let i = 0; i < totalFiles; i += batchSize) {
    const batch = files.slice(i, i + batchSize);
    const batchIndex = Math.floor(i / batchSize) + 1;
    const startIndex = i;
    const endIndex = Math.min(i + batchSize - 1, totalFiles - 1);
    const batchStartTime = Date.now();
    
    console.log(`[分批次处理][${operationId}] 开始处理批次 ${batchIndex}/${totalBatches}，文件数量: ${batch.length}，文件范围: ${startIndex}-${endIndex}`);
    console.log(`[分批次处理][${operationId}] 当前进度: ${processedFiles}/${totalFiles} 文件 (${Math.round((processedFiles / totalFiles) * 100)}%)，${processedBatches}/${totalBatches} 批次 (${Math.round((processedBatches / totalBatches) * 100)}%)`);
    
    try {
      // 处理当前批次
      const batchInfo = {
        batchIndex: batchIndex,
        totalBatches: totalBatches,
        startIndex: startIndex,
        endIndex: endIndex,
        totalFiles: totalFiles,
        operationId
      };
      
      console.log(`[分批次处理][${operationId}] 调用处理函数处理批次 ${batchIndex}`);
      const batchResult = await processFunction(batch, batchInfo);
      
      // 确保batchResult是有效的对象
      if (!batchResult || typeof batchResult !== 'object') {
        console.error(`[分批次处理][${operationId}] 警告: 批次 ${batchIndex} 的处理函数返回了无效结果`);
        const errorResult = {
          batchIndex: batchIndex,
          error: 'Batch returned null/undefined result',
          successCount: 0,
          errorCount: batch.length,
          results: []
        };
        allResults.push(errorResult);
        errorCount += batch.length;
      } else {
        console.log(`[分批次处理][${operationId}] 批次 ${batchIndex}/${totalBatches} 处理完成，耗时: ${Date.now() - batchStartTime}ms`);
        console.log(`[分批次处理][${operationId}] 批次 ${batchIndex}/${totalBatches} 统计: 成功数: ${batchResult.successCount || 0}，失败数: ${batchResult.errorCount || 0}`);
        
        // 收集结果
        allResults.push(batchResult);
        
        // 更新统计信息
        if (batchResult.successCount !== undefined) {
          successCount += batchResult.successCount;
        }
        if (batchResult.errorCount !== undefined) {
          errorCount += batchResult.errorCount;
        }
      }
      
      processedBatches++;
      processedFiles += batch.length;
      
    } catch (batchError) {
      console.error(`[分批次处理][${operationId}] 批次 ${batchIndex}/${totalBatches} 处理过程中出错:`, batchError);
      console.error(`[分批次处理][${operationId}] 错误详情:`, batchError.stack || String(batchError));
      
      // 即使批次处理失败，也记录错误并继续处理下一批
      errorCount += batch.length;
      
      const errorResult = {
        results: [],
        successCount: 0,
        errorCount: batch.length,
        error: batchError.message,
        stack: batchError.stack,
        batchIndex: batchIndex,
        failedAt: new Date().toISOString()
      };
      
      allResults.push(errorResult);
      processedBatches++;
      processedFiles += batch.length;
    }
    
    // 添加短暂延迟，让UI有机会更新
    if (i + batchSize < totalFiles) {
      console.log(`[分批次处理][${operationId}] 批次 ${batchIndex} 完成，准备处理下一批，等待200ms...`);
      await new Promise(resolve => setTimeout(resolve, 200));
      console.log(`[分批次处理][${operationId}] 延迟结束，准备处理下一批次`);
    }
  }
  
  const totalDuration = Date.now() - startTime;
  const successRate = totalFiles > 0 ? ((successCount / totalFiles) * 100).toFixed(2) : 0;
  
  console.log(`[分批次处理][${operationId}] 所有批次处理完成，总耗时: ${totalDuration}ms`);
  console.log(`[分批次处理][${operationId}] 处理统计: 总文件数: ${totalFiles}，成功数: ${successCount}，失败数: ${errorCount}，成功率: ${successRate}%`);
  console.log(`[分批次处理][${operationId}] 性能统计: 平均每个批次耗时: ${Math.round(totalDuration / totalBatches)}ms，平均每个文件耗时: ${Math.round(totalDuration / totalFiles)}ms`);
  
  return {
    success: true,
    successCount,
    errorCount,
    results: allResults,
    totalBatches,
    totalFiles,
    operationId,
    startTime,
    endTime: Date.now(),
    durationMs: totalDuration,
    completedAt: new Date().toISOString(),
    stats: {
      avgBatchTimeMs: Math.round(totalDuration / totalBatches),
      avgFileTimeMs: Math.round(totalDuration / totalFiles),
      processedBatches,
      processedFiles,
      successRate: parseFloat(successRate)
    }
  };
}

app.whenReady().then(() => {
  createWindow();
  
  // 启动后立即测试二维码保存功能
  // setTimeout(testQrCodeSave, 2000);
  
  // 测试文件处理和二维码生成功能
  // setTimeout(async () => {
  //   console.log('[测试] 开始测试文件处理和二维码生成功能');
  //   // 使用用户提到的测试文件夹路径
  //   const testFolderPath = 'E:\\测试文件夹';
  //   console.log('[测试] 测试文件夹路径:', testFolderPath);
    
  //   try {
  //     // 检查文件夹是否存在
  //     if (fs.existsSync(testFolderPath)) {
  //       console.log('[测试] 测试文件夹存在，开始处理...');
        
  //       // 读取文件夹中的文件
  //       const files = fs.readdirSync(testFolderPath);
  //       console.log('[测试] 找到文件数量:', files.length);
        
  //       // 模拟文件内容，并创建足够多的测试文件来触发分批次处理
  //       let mockFiles = files.filter(file => file.endsWith('.html')).map((file, index) => ({
  //         name: file,
  //         path: path.join(testFolderPath, file),
  //         content: `测试内容 ${index + 1}`
  //       }));
        
  //       // 如果文件数量少于20个，创建额外的模拟文件以确保触发分批次处理
  //       if (mockFiles.length < 20) {
  //         const additionalFiles = [];
  //         for (let i = mockFiles.length; i < 20; i++) {
  //           additionalFiles.push({
  //             name: `mock_file_${i + 1}.html`,
  //             path: path.join(testFolderPath, `mock_file_${i + 1}.html`),
  //             content: `模拟测试内容 ${i + 1}`
  //           });
  //         }
  //         mockFiles = [...mockFiles, ...additionalFiles];
  //         console.log('[测试] 添加了额外的模拟文件，总计:', mockFiles.length);
  //       }
        
  //       console.log('[测试] 文件内容准备完成，开始测试分批次处理逻辑');
        
  //       // 模拟保存路径
  //       const testSavePath = path.join(process.env.HOME || process.env.USERPROFILE, 'Desktop', 'QRTest2');
  //       console.log('[测试] 测试保存路径:', testSavePath);
        
  //       // 确保保存路径存在
  //       if (!fs.existsSync(testSavePath)) {
  //         fs.mkdirSync(testSavePath, { recursive: true });
  //       }
        
  //       console.log('[测试] 开始测试分批次处理逻辑...');
        
  //       // 直接调用分批次处理函数进行测试
  //       const testBatchResult = await processFilesInBatches(mockFiles, 10, async (batch, batchInfo) => {
  //         console.log(`[测试] 处理批次 ${batchInfo.batchIndex}/${batchInfo.totalBatches}，文件数量: ${batch.length}`);
          
  //         // 模拟处理每个文件
  //         const batchResults = [];
  //         batch.forEach((file, fileIndex) => {
  //           console.log(`[测试] 处理文件: ${file.name} (批次内索引: ${fileIndex})`);
            
  //           // 模拟文件分片（假设每个文件需要2个二维码）
  //           const chunkCount = 2;
            
  //           // 模拟生成和保存每个分片的二维码
  //           for (let i = 1; i <= chunkCount; i++) {
  //             const globalIndex = batchInfo.startIndex + fileIndex + 1;
  //             const mockQrPath = path.join(testSavePath, `${globalIndex}-${i}.png`);
  //             console.log(`[测试] 保存分片二维码到: ${mockQrPath}`);
              
  //             // 创建空文件模拟保存成功
  //             fs.writeFileSync(mockQrPath, '');
  //             batchResults.push({
  //               file: file.name,
  //               chunkIndex: i,
  //               path: mockQrPath,
  //               success: true
  //             });
  //           }
  //         });
          
  //         return {
  //           successCount: batchResults.length,
  //           errorCount: 0,
  //           results: batchResults
  //         };
  //       });
        
  //       console.log(`[测试] 分批次处理测试完成，总成功数: ${testBatchResult.successCount}`);
  //       console.log(`[测试] 测试流程完成`);
  //     } else {
  //       console.log('[测试] 测试文件夹不存在，跳过测试');
  //     }
  //   } catch (error) {
  //     console.error('[测试] 测试过程中发生错误:', error);
  //   }
  // }, 5000);
  
  // 确保目录存在的处理器
  ipcMain.handle('ensure-directory', async (event, directoryPath) => {
    try {
      console.log('[主进程] ensure-directory: 检查目录是否存在:', directoryPath);
      
      // 规范化路径格式
      const normalizedPath = path.normalize(directoryPath);
      console.log('[主进程] ensure-directory: 规范化路径:', normalizedPath);
      
      // 检查并创建目录（如果不存在）
      if (!fs.existsSync(normalizedPath)) {
        console.log('[主进程] ensure-directory: 目录不存在，尝试创建:', normalizedPath);
        fs.mkdirSync(normalizedPath, { recursive: true });
        console.log('[主进程] ensure-directory: 目录创建成功');
      } else {
        console.log('[主进程] ensure-directory: 目录已存在');
      }
      
      // 再次验证目录是否存在
      if (fs.existsSync(normalizedPath)) {
        console.log('[主进程] ensure-directory: 验证通过，目录确实存在');
        return { success: true, path: normalizedPath };
      } else {
        console.error('[主进程] ensure-directory: 验证失败，目录创建后仍不存在');
        throw new Error('Failed to create directory');
      }
    } catch (error) {
      console.error('[主进程] ensure-directory: 处理失败:', error.message);
      throw new Error(`Failed to ensure directory: ${error.message}`);
    }
  });

  // 处理文件路径解析（支持文件和文件夹）
  ipcMain.handle('select-file-by-path', async (event, params) => {
    try {
      const fileInfos = [];
      // 从params中获取paths和filterKeywords
      const paths = typeof params === 'string' ? params : params.paths;
      const filterKeywords = typeof params === 'string' ? '' : (params.filterKeywords || '');
      
      console.log('开始处理文件路径，过滤关键字:', filterKeywords);
      
      // 分割文件路径（支持分号分隔多个路径）
      const pathList = paths.split(';').map(p => p.trim()).filter(p => p.length > 0);
      
      for (const filePath of pathList) {
        try {
          // 检查路径是否存在
          const stats = fs.statSync(filePath);
          
          // 检查根路径是否需要过滤
          if (shouldFilterPath(filePath, filterKeywords)) {
            console.log(`[过滤] 跳过根路径: ${filePath}`);
            logSkippedFile({
              name: path.basename(filePath),
              path: filePath,
              reason: '路径过滤'
            });
            continue;
          }
          
          if (stats.isDirectory()) {
            // 处理文件夹：递归收集所有支持的代码文件信息，但不立即读取内容
            console.log(`处理文件夹: ${filePath}`);
            const folderFileInfos = getCodeFilesFromDirectory(filePath, filterKeywords);
            console.log(`从目录 ${filePath} 找到 ${folderFileInfos.length} 个文件（已应用过滤）`);
            fileInfos.push(...folderFileInfos);
          } else if (stats.isFile()) {
            // 处理单个文件
            // 检查是否为支持的代码文件类型
            const ext = path.extname(filePath);
            if (!codeExtensions.includes(ext)) {
              console.warn(`跳过不支持的文件类型: ${filePath}`);
              continue;
            }
            
            // 只收集文件信息，不立即读取内容
            fileInfos.push({
              name: path.basename(filePath),
              path: filePath,
              size: stats.size
            });
          } else {
            console.warn(`跳过非文件非文件夹路径: ${filePath}`);
          }
        } catch (error) {
          console.error(`处理路径时出错: ${filePath}`, error);
          // 继续处理其他路径
        }
      }
      
      // 如果文件数量较多，使用分批读取策略
      if (fileInfos.length > 10) {
        console.log(`发现 ${fileInfos.length} 个文件，开始分批读取内容...`);
        
        // 发送进度通知
        event.sender.send('file-processing-start', {
          totalFiles: fileInfos.length
        });
        
        // 分批读取文件内容
        const files = await readFilesContentInBatches(fileInfos, 10);
        
        return files;
      } else {
        // 文件数量较少时，直接读取所有内容
        const files = fileInfos.map(fileInfo => {
          try {
            const content = fs.readFileSync(fileInfo.path, 'utf-8');
            return {
              ...fileInfo,
              content: content
            };
          } catch (error) {
            console.error(`读取文件内容时出错: ${fileInfo.path}`, error);
            return {
              ...fileInfo,
              content: '',
              error: error.message
            };
          }
        });
        
        return files;
      }
    } catch (error) {
      console.error('解析文件路径时出错:', error);
      throw error;
    }
  });
  
  // 选择文件夹功能已移除，只保留通过文件路径解析的方式
  
  // 处理保存路径选择（只返回文件夹路径）
  ipcMain.handle('select-save-directory', async () => {
    const result = await dialog.showOpenDialog({
      properties: ['openDirectory']
    });
    
    if (!result.canceled && result.filePaths.length > 0) {
      return result.filePaths;
    }
    
    return [];
  });
  
  // 获取下一个可用的文件序号
ipcMain.handle('get-next-file-index', async (event, savePath) => {
    try {
      // 检查路径是否存在，不存在则创建
      if (!fs.existsSync(savePath)) {
        fs.mkdirSync(savePath, { recursive: true });
      }
      
      // 查找下一个可用的序号
      let nextIndex = 1;
      const existingFiles = fs.readdirSync(savePath);
      // 修改正则表达式，确保能正确匹配主序号，不考虑分片后缀或其他格式
      const numericRegex = /^(\d+)(?:\-\d+)?(?:\((\d+)\))?\.png$/;
      
      existingFiles.forEach(file => {
        if (file.endsWith('.png')) {
          const match = file.match(numericRegex);
          if (match) {
            // 只获取主序号部分
            const fileNumber = parseInt(match[1], 10);
            // 确保nextIndex总是比最大的已存在序号大1
            if (fileNumber >= nextIndex) {
              nextIndex = fileNumber + 1;
            }
          }
        }
      });
      
      return nextIndex;
    } catch (error) {
      console.error('获取下一个文件序号失败:', error);
      return 1; // 出错时返回默认序号
    }
  });

  // 添加测试二维码生成和保存的函数
  function testQrCodeSave() {
    console.log('开始测试二维码保存功能...');
    
    // 生成一个简单的二维码测试数据
    const testSavePath = path.join(process.env.HOME || process.env.USERPROFILE, 'Desktop', 'QRTest');
    console.log(`测试保存路径: ${testSavePath}`);
    
    // 测试直接调用保存函数
    QRCode.toDataURL('测试二维码数据')
      .then(dataUrl => {
        console.log('生成测试二维码成功');
        
        // 使用模拟数据测试save-qrcode逻辑
        const chunkInfo = { fileIndex: 1 };
        const params = { dataUrl, savePath: testSavePath, baseName: '', chunkInfo };
        
        // 直接调用保存处理函数的逻辑，而不是通过IPC
        try {
          // 确保保存路径存在
          if (!fs.existsSync(testSavePath)) {
            console.log('创建保存路径...');
            fs.mkdirSync(testSavePath, { recursive: true });
          }
          
          // 生成文件名
          let fileName = `1.png`;
          let filePath = path.join(testSavePath, fileName);
          
          console.log(`准备保存测试二维码到: ${filePath}`);
          
          // 解码base64数据并写入文件
          const base64Data = dataUrl.replace(/^data:image\/png;base64,/, '');
          const buffer = Buffer.from(base64Data, 'base64');
          
          fs.writeFileSync(filePath, buffer);
          console.log(`测试二维码保存成功: ${filePath}`);
        } catch (error) {
          console.error('测试二维码保存失败:', error);
        }
      })
      .catch(error => {
        console.error('生成测试二维码失败:', error);
      });
  }

  // 处理保存二维码请求
ipcMain.handle('save-qrcode', async (event, { dataUrl, savePath, baseName, chunkInfo }) => {
    try {
        console.log('[主进程] 接收到保存二维码请求');
        console.log('[主进程] 保存路径:', savePath);
        console.log('[主进程] 分片信息:', chunkInfo);
        
        // 从chunkInfo中获取文件序号，如果没有则使用1
        let fileIndex = chunkInfo?.fileIndex || 1;
        console.log('[主进程] 文件序号:', fileIndex);
        
        // 判断是否为分片文件及分片索引
        const isSplit = chunkInfo?.isSplit === true;
        const chunkIndex = chunkInfo?.chunkIndex;
        console.log('[主进程] 是否分片:', isSplit, '分片索引:', chunkIndex);
        
        // 确保保存路径存在（修复路径创建问题）
        console.log('[主进程] 检查保存路径是否存在:', savePath);
        if (!fs.existsSync(savePath)) {
            console.log('[主进程] 保存路径不存在，创建中...');
            fs.mkdirSync(savePath, { recursive: true });
            // 确认路径创建成功
            if (!fs.existsSync(savePath)) {
                console.error('[主进程] 路径创建失败:', savePath);
                return {
                    success: false,
                    error: '创建保存路径失败',
                    details: '无法创建目标目录'
                };
            }
            console.log('[主进程] 保存路径创建成功');
        }
        
        // 生成文件名，严格按照用户要求的格式
        let fileName;
        if (isSplit && chunkIndex !== undefined) {
            // 分片文件格式："序号-(分片序号-1).png"
            fileName = `${fileIndex}-${chunkIndex}.png`;
        } else {
            // 非分片文件格式："序号.png"
            fileName = `${fileIndex}.png`;
        }
        console.log('[主进程] 生成的文件名:', fileName);
        
        let filePath = path.join(savePath, fileName);
        console.log('[主进程] 完整文件路径:', filePath);
        
        // 检查文件是否存在，如果存在则增加序号继续尝试
        if (fs.existsSync(filePath)) {
            console.log('[主进程] 文件已存在:', filePath);
            // 如果文件已存在，增加序号并重新生成文件名
            fileIndex++;
            console.log('[主进程] 增加序号为:', fileIndex);
            if (isSplit && chunkIndex !== undefined) {
                fileName = `${fileIndex}-${chunkIndex}.png`;
            } else {
                fileName = `${fileIndex}.png`;
            }
            filePath = path.join(savePath, fileName);
            console.log('[主进程] 新的文件路径:', filePath);
        }
        
        // 验证dataUrl是否有效
        if (!dataUrl || typeof dataUrl !== 'string' || !dataUrl.startsWith('data:image/png;base64,')) {
            console.error('[主进程] 无效的dataUrl:', typeof dataUrl, dataUrl?.substring(0, 30) + '...');
            return {
                success: false,
                error: '无效的二维码数据',
                details: 'dataUrl格式不正确'
            };
        }
        
        // 解码base64数据并写入文件
        console.log('[主进程] 开始解码base64数据...');
        const base64Data = dataUrl.replace(/^data:image\/png;base64,/, '');
        console.log('[主进程] base64数据解码完成，数据长度:', base64Data.length, '字符');
        
        console.log('[主进程] 转换base64数据为Buffer...');
        const buffer = Buffer.from(base64Data, 'base64');
        console.log('[主进程] Buffer转换完成，Buffer大小:', buffer.length, '字节');
        
        console.log('[主进程] 开始写入文件:', filePath);
        
        // 使用writeFile替代writeFileSync，确保异步写入更可靠
        await new Promise((resolve, reject) => {
            fs.writeFile(filePath, buffer, (err) => {
                if (err) {
                    console.error('[主进程] 写入文件失败:', err.message);
                    reject(err);
                } else {
                    // 验证文件是否成功写入
                    if (fs.existsSync(filePath)) {
                        const stats = fs.statSync(filePath);
                        console.log('[主进程] 二维码保存成功:', filePath, '文件大小:', stats.size, '字节');
                        resolve();
                    } else {
                        const writeError = new Error('文件未创建成功');
                        console.error('[主进程] 验证文件存在失败:', filePath);
                        reject(writeError);
                    }
                }
            });
        });
        
        return {
            success: true,
            filePath: filePath,
            fileName: path.basename(filePath)
        };
    } catch (error) {
        console.error('[主进程] 保存二维码时出错:', error);
        return {
            success: false,
            error: '保存二维码时出错',
            details: error.message
        };
    }
});

  // 生成二维码 - 为每个文件单独生成二维码，如果内容过大则分片生成多个
  // 使用分块处理避免一次处理过多文件导致程序卡死
  ipcMain.handle('generate-qrcode', async (event, { files, savePath: userSavePath }) => {
    // 清空之前的跳过文件记录
    skippedFiles = [];
    
    // 使用用户提供的保存路径，如果没有提供则使用默认路径
    let savePath = userSavePath || path.join(app.getPath('downloads'), '二维码文件');
    console.log('[generate-qrcode] 用户提供的保存路径:', userSavePath || '未提供，使用默认路径');
    console.log('[generate-qrcode] 最终使用的二维码保存路径:', savePath);
    console.log('[generate-qrcode] 开始处理二维码生成请求，文件数量:', files.length);
    
    // 参数验证
    if (!Array.isArray(files)) {
      console.error('[generate-qrcode] 错误: files参数必须是数组');
      return {
        success: false,
        error: 'Invalid files parameter',
        results: [],
        successCount: 0,
        errorCount: 0
      };
    }
    
    try {
      // 计算总片数
      let totalChunks = 0;
      for (const file of files) {
        const contentChunks = splitContent(file.content || '');
        totalChunks += contentChunks.length;
      }
      
      // 发送进度初始化通知
      event.sender.send('qrcode-progress-init', { 
        totalFiles: files.length, 
        totalChunks,
        isBatchProcessing: files.length > 10 // 标记是否使用批处理
      });
      
      // 定义统一的批处理函数，同时适用于批处理和单批次模式
      const processBatch = async (batchFiles, batchInfo) => {
        // 从batchInfo中获取savePath，如果没有则使用默认路径
        const currentSavePath = batchInfo.savePath || savePath;
        console.log(`[generate-qrcode] 批处理中使用的保存路径: ${currentSavePath}`);
        console.log(`[generate-qrcode] 处理批次 ${batchInfo.batchIndex}/${batchInfo.totalBatches}，文件数量: ${batchFiles.length}，总文件数: ${batchInfo.totalFiles || files.length}`);
        
        const batchResults = [];
        let batchSuccessCount = 0;
        let batchErrorCount = 0;
        
        // 处理当前批次的文件
        for (const file of batchFiles) {
          try {
            // 验证文件信息
            if (!file || !file.name) {
              throw new Error('无效的文件信息');
            }
            
            console.log(`[generate-qrcode] 处理文件: ${file.name}`);
            
            // 将文件内容分片
            const contentChunks = splitContent(file.content || '');
            console.log(`[generate-qrcode] 文件 ${file.name} 被拆分为 ${contentChunks.length} 个部分`);
            
            // 为每个分片生成二维码
            for (const chunk of contentChunks) {
              try {
                // 优化单个文件数据结构，包含分片信息
                const optimizedFile = {
                  name: file.name,
                  path: file.path || '',
                  content: chunk.content,
                  isSplit: chunk.isSplit,
                  chunkIndex: chunk.chunkIndex || 1,
                  totalChunks: chunk.totalChunks || 1
                };
                
                // 准备要编码的数据
                const dataToEncode = JSON.stringify(optimizedFile);
                
                // 计算数据大小
                const dataSize = Buffer.byteLength(dataToEncode, 'utf8');
                console.log(`[generate-qrcode] 编码数据大小: ${dataSize} 字节`);
                
                // 配置二维码参数 - 优化可读性
                const qrOptions = {
                  version: undefined, // 自动选择适合的版本
                  errorCorrectionLevel: 'L', // 低容错级别，适合图片传递
                  margin: 2, // 增加边距，避免扫码时边缘识别问题
                  scale: 5, // 增加缩放比例，使二维码更加清晰
                  width: 400, // 调整宽度为适中大小
                  type: 'image/png' // 输出格式
                };
                
                // 生成二维码数据URL
                console.log(`[generate-qrcode] 生成二维码: ${file.name} 分片 ${chunk.chunkIndex || 1}/${chunk.totalChunks || 1}`);
                const qrCodeDataUrl = await QRCode.toDataURL(dataToEncode, qrOptions);
                console.log(`[generate-qrcode] 二维码数据URL生成成功，数据长度: ${qrCodeDataUrl.length} 字符`);
                
                // 调试：检查二维码数据是否有效
                if (!qrCodeDataUrl || !qrCodeDataUrl.startsWith('data:image/png;base64,')) {
                  console.error(`[generate-qrcode] 警告: 生成的二维码数据URL无效`);
                } else {
                  console.log(`[generate-qrcode] 二维码数据URL有效，格式正确`);
                }
                
                // 修复：在批处理模式下保存二维码到文件系统
                console.log(`[generate-qrcode] 准备保存二维码到文件系统...`);
                // 计算文件序号 - 在批处理中需要考虑批次偏移
                const globalFileIndex = (batchInfo.startIndex || 0) + batchFiles.indexOf(file) + 1;
                console.log(`[generate-qrcode] 计算全局文件序号: ${globalFileIndex}`);
                
                // 调用saveQRCode函数保存二维码
                const saveResult = await saveQRCode(qrCodeDataUrl, currentSavePath, {
                  fileIndex: globalFileIndex,
                  isSplit: chunk.isSplit,
                  chunkIndex: chunk.chunkIndex,
                  fileName: file.name // 添加原始文件名，便于调试和追踪
                });
                console.log(`[generate-qrcode] 二维码保存结果: ${saveResult.success ? '成功' : '失败'}`);
                if (saveResult.success) {
                  console.log(`[generate-qrcode] 二维码已保存到: ${saveResult.filePath}`);
                } else {
                  console.error(`[generate-qrcode] 二维码保存失败: ${saveResult.error} - ${saveResult.details}`);
                }
                
                // 构建结果对象 - 确保dataUrl使用正确生成的二维码数据
                const result = {
                  fileName: file.name,
                  chunkIndex: chunk.chunkIndex,
                  totalChunks: chunk.totalChunks,
                  isSplit: chunk.isSplit,
                  success: true,
                  dataUrl: qrCodeDataUrl, // 直接使用生成的二维码数据URL
                  filePath: saveResult.success ? saveResult.filePath : null,
                  message: chunk.isSplit 
                    ? `成功为 ${file.name} 分片 ${chunk.chunkIndex}/${chunk.totalChunks} 生成二维码`
                    : `成功为 ${file.name} 生成二维码`
                };
                
                console.log(`[generate-qrcode] 构建结果对象完成，准备添加到批次结果中`);
                batchResults.push(result);
                batchSuccessCount++;
                
                // 发送进度更新（单批次模式时）
                if (batchInfo.totalBatches === 1) {
                  event.sender.send('qrcode-progress-update', {
                    fileName: file.name,
                    currentChunk: chunk.chunkIndex || 1,
                    totalChunks: chunk.totalChunks || 1,
                    processedChunks: batchSuccessCount + batchErrorCount,
                    totalChunks: totalChunks,
                    progress: Math.round(((batchSuccessCount + batchErrorCount) / totalChunks) * 100)
                  });
                }
                
              } catch (chunkError) {
                console.error(`[generate-qrcode] 为文件 ${file.name} 分片 ${chunk.chunkIndex || 1} 生成二维码时出错:`, chunkError);
                
                // 实时记录失败的文件信息
                logSkippedFile({
                  name: file.name,
                  path: file.path || '',
                  reason: `生成二维码失败: ${chunkError.message}`
                });
                
                batchResults.push({
                  fileName: file.name,
                  chunkIndex: chunk.chunkIndex,
                  totalChunks: chunk.totalChunks,
                  isSplit: chunk.isSplit,
                  success: false,
                  error: '生成二维码分片时出错',
                  details: chunkError.message,
                  timestamp: new Date().toISOString()
                });
                batchErrorCount++;
                
                // 发送进度更新（单批次模式时）
                if (batchInfo.totalBatches === 1) {
                  event.sender.send('qrcode-progress-update', {
                    fileName: file.name,
                    currentChunk: chunk.chunkIndex || 1,
                    totalChunks: chunk.totalChunks || 1,
                    processedChunks: batchSuccessCount + batchErrorCount,
                    totalChunks: totalChunks,
                    progress: Math.round(((batchSuccessCount + batchErrorCount) / totalChunks) * 100)
                  });
                }
              }
            }
            
          } catch (fileError) {
            console.error(`[generate-qrcode] 处理文件 ${file.name} 时出错:`, fileError);
            
            batchResults.push({
              fileName: file.name,
              success: false,
              error: '处理文件时出错',
              details: fileError.message,
              timestamp: new Date().toISOString()
            });
            batchErrorCount++;
          }
        }
        
        // 发送批次完成通知（多批次模式时）
        if (batchInfo.totalBatches > 1) {
          event.sender.send('qrcode-batch-complete', {
            batchIndex: batchInfo.batchIndex,
            totalBatches: batchInfo.totalBatches,
            batchSuccessCount,
            batchErrorCount,
            processedFiles: batchFiles.length,
            totalFiles: batchInfo.totalFiles || files.length
          });
        }
        
        console.log(`[generate-qrcode] 批次 ${batchInfo.batchIndex}/${batchInfo.totalBatches} 处理完成，成功: ${batchSuccessCount}，失败: ${batchErrorCount}`);
        
        return {
          results: batchResults,
          successCount: batchSuccessCount,
          errorCount: batchErrorCount,
          batchIndex: batchInfo.batchIndex,
          processedAt: new Date().toISOString()
        };
      };
      
      // 使用统一的批处理逻辑，无论文件数量多少
      const batchSize = files.length > 10 ? 10 : files.length;
      console.log(`[generate-qrcode] ${batchSize < files.length ? '启用批处理模式' : '使用单批次处理'}，文件数量: ${files.length}，批次大小: ${batchSize}`);
      
      // 分块处理所有文件 - 确保savePath传递给每个批次
      let processingResult;
      
      // 优化：直接调用processBatch处理单个文件，避免不必要的批处理复杂性
      if (files.length === 1) {
        console.log('[generate-qrcode] 单个文件处理模式');
        processingResult = await processBatch(files, {
          batchIndex: 1,
          totalBatches: 1,
          startIndex: 0,
          totalFiles: 1,
          savePath: savePath
        });
        // 确保返回结构一致
        processingResult = {
          ...processingResult,
          totalBatches: 1,
          totalFiles: 1
        };
      } else {
        // 多文件批处理模式
        processingResult = await processFilesInBatches(files, batchSize, async (batchFiles, batchInfo) => {
          // 增强batchInfo，添加savePath信息
          const enhancedBatchInfo = {
            ...batchInfo,
            savePath: savePath
          };
          return await processBatch(batchFiles, enhancedBatchInfo);
        });
      }
      
      console.log(`[generate-qrcode] 批处理完成，总结果: ${JSON.stringify({ 
        successCount: processingResult.successCount, 
        errorCount: processingResult.errorCount,
        totalBatches: processingResult.totalBatches,
        totalFiles: processingResult.totalFiles 
      }, null, 2)}`);
      
      // 确保结果数组被正确扁平化，无论嵌套结构如何
      const flattenedResults = [];
      if (Array.isArray(processingResult.results)) {
        processingResult.results.forEach(batch => {
          if (Array.isArray(batch)) {
            // 如果batch本身是数组，直接添加所有元素
            flattenedResults.push(...batch);
          } else if (Array.isArray(batch.results)) {
            // 如果batch有results属性是数组，添加其中的元素
            flattenedResults.push(...batch.results);
          } else if (batch) {
            // 如果batch是单个对象，添加它
            flattenedResults.push(batch);
          }
        });
      }
      
      console.log(`[generate-qrcode] 扁平化后的结果数量: ${flattenedResults.length}`);
      
      // 调试：检查结果中的二维码数据是否包含dataUrl
      const hasDataUrls = flattenedResults.some(result => result && result.dataUrl);
      console.log(`[generate-qrcode] 最终结果中${hasDataUrls ? '包含' : '不包含'}二维码数据URL`);
      if (hasDataUrls) {
        const firstResult = flattenedResults.find(r => r && r.dataUrl);
        console.log(`[generate-qrcode] 第一个结果示例: fileName=${firstResult?.fileName}, hasDataUrl=${!!firstResult?.dataUrl}`);
      }
      
      console.log(`[generate-qrcode] 警告: 检查是否缺少保存二维码到文件系统的步骤!`);
      
      // 将被跳过的文件信息写入文件
      const skippedFilesLogPath = writeSkippedFilesInfo(savePath);
      
      return {
        success: true,
        results: flattenedResults,
        successCount: processingResult.successCount || 0,
        errorCount: processingResult.errorCount || 0,
        totalBatches: processingResult.totalBatches || 1,
        totalFiles: processingResult.totalFiles || files.length,
        skippedFilesLogPath: skippedFilesLogPath,
        message: `二维码生成完成，成功: ${processingResult.successCount || 0} 个，失败: ${processingResult.errorCount || 0} 个`,
        completedAt: new Date().toISOString()
      };
      
    } catch (error) {
      console.error('[generate-qrcode] 处理二维码生成任务时出错:', error);
      return {
        success: false,
        error: '处理二维码生成任务时出错',
        details: error.message,
        timestamp: new Date().toISOString(),
        results: [],
        successCount: 0,
        errorCount: files.length
      };
    }
  });
  
  // 将内容分片，每片不超过maxSize大小
  // 使用较大分片大小，因为使用低容错级别可以存储更多数据
    function splitContent(content, maxSize = 800) {
    if (content.length <= maxSize) {
      // 内容小于等于最大大小，返回单元素数组
      return [{ content: content, isSplit: false }];
    }
    
    // 内容需要分片
    const chunks = [];
    const totalChunks = Math.ceil(content.length / maxSize);
    
    for (let i = 0; i < totalChunks; i++) {
      const start = i * maxSize;
      const end = Math.min(start + maxSize, content.length);
      const chunkContent = content.substring(start, end);
      
      chunks.push({
        content: chunkContent,
        isSplit: true,
        chunkIndex: i + 1, // 从1开始的分片索引
        totalChunks: totalChunks
      });
    }
    
    return chunks;
  }
  
  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

// IPC通信处理
// 读取所有跳过文件历史记录
ipcMain.handle('read-skipped-files-history', () => {
  return readSkippedFilesHistory();
});

// 按日期读取跳过文件历史记录
ipcMain.handle('read-skipped-files-by-date', (event, date) => {
  return readSkippedFilesByDate(date);
});

// 清空跳过文件历史记录
ipcMain.handle('clear-skipped-files-history', () => {
  return clearSkippedFilesHistory();
});